package org.becomingMd;

import java.io.File;
import java.sql.*;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class ConDatabases {
    private Connection conn;

    // 构造函数，初始化数据库连接
    public ConDatabases() throws SQLException {
        // 获取连接
        conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/flomo", "root", "123456");
    }

    /**
     * 检查文件记录是否存在，并在存在时更新文件是否存在的标志。
     *
     * @param absolutePath 文件的绝对路径
     * @return 如果文件记录存在，则返回 true，否则返回 false
     * @throws SQLException 如果数据库操作过程中发生错误
     */
    public boolean isFileRecord(String absolutePath) throws SQLException {
        String selectSql = "SELECT * FROM FileInfo WHERE absolute_path = ?";
        try (PreparedStatement pstmt = conn.prepareStatement(selectSql)) {
            pstmt.setString(1, absolutePath);
            ResultSet rs = pstmt.executeQuery();
            if (rs.next()) { // 如果查询结果有记录
                // 文件记录存在，更新 is_existed 字段为 1
                String updateSql = "UPDATE FileInfo SET is_existed = 1 WHERE absolute_path = ?";
                try (PreparedStatement updateStmt = conn.prepareStatement(updateSql)) {
                    updateStmt.setString(1, absolutePath);
                    updateStmt.executeUpdate();
                    return true; // 返回 true 表示记录存在并已更新
                }
            }
        }
        return false; // 如果查询结果没有记录，返回 false
    }

    /**
     * 将所有文件的 is_existed 字段重置为 0。
     *
     * @throws SQLException 如果数据库操作过程中发生错误
     */
    public void resetIsExisted() throws SQLException {
        String updateSql = "UPDATE FileInfo SET is_existed = 0, is_Synced = 0";
        try (PreparedStatement pstmt = conn.prepareStatement(updateSql)) {
            pstmt.executeUpdate();
        }
    }
    /**
     * 获取所有 isSynced 为 1 的 absolute_path 的 File 集合
     *
     * @return 包含所有 isSynced 为 1 的 File 对象的 List
     * @throws SQLException 如果数据库操作过程中发生错误
     */
    public List<File> getSyncedFilePaths() throws SQLException {
        List<File> syncedFiles = new ArrayList<>();
        String selectSql = "SELECT absolute_path FROM FileInfo WHERE is_synced = 1";
        try (PreparedStatement pstmt = conn.prepareStatement(selectSql)) {
            ResultSet rs = pstmt.executeQuery();
            while (rs.next()) {
                // 获取路径并替换反斜杠为双反斜杠
                String filePath = rs.getString("absolute_path").replace("\\", "\\\\");
                // 创建 File 对象并添加到列表中
                syncedFiles.add(new File(filePath));
            }
        }
        return syncedFiles;
    }
    /**
     * 重置所有记录的同步状态为0，然后将匹配传入文件名的记录设置为1
     * @param fileNames 需要设置为已同步的文件名列表
     * @throws SQLException 如果数据库操作过程中发生错误
     */
    public void updateSyncStatus(List<String> fileNames) throws SQLException {
        // 第一步：将所有记录的 is_synced 字段设置为 0
        String resetSql = "UPDATE FileInfo SET is_synced = 0";
        try (PreparedStatement resetStmt = conn.prepareStatement(resetSql)) {
            resetStmt.executeUpdate();
        }

        // 第二步：将匹配传入文件名的记录的 is_synced 字段设置为 1
        if (fileNames != null && !fileNames.isEmpty()) {
            String updateSql = "UPDATE FileInfo SET is_synced = 1 WHERE file_name = ?";
            try (PreparedStatement updateStmt = conn.prepareStatement(updateSql)) {
                for (String fileName : fileNames) {
                    updateStmt.setString(1, fileName);
                    updateStmt.addBatch(); // 添加到批处理
                }
                updateStmt.executeBatch(); // 执行批处理
            }
        }
    }
    /**
     * 删除所有 is_existed = 0 的记录。
     *
     * @throws SQLException 如果数据库操作过程中发生错误
     */
    public void deleteNonExistedFiles() throws SQLException {
        String deleteSql = "DELETE FROM FileInfo WHERE is_existed = 0";
        try (PreparedStatement pstmt = conn.prepareStatement(deleteSql)) {
            pstmt.executeUpdate();
        }
    }
    /**
     * 创建文件记录
     *
     * @param fileInfo 文件信息对象
     */
    public void createFileRecord(FileInfo fileInfo){
        String sql = "INSERT INTO FileInfo (absolute_path, file_name, file_size, file_type, is_existed, is_synced) VALUES (?, ?, ?, ?, ?, ?)";
        try (PreparedStatement pstmt = conn.prepareStatement(sql)) {
            pstmt.setString(1, fileInfo.getAbsolutePath());
            pstmt.setString(2, fileInfo.getFileName());
            pstmt.setInt(3, fileInfo.getFileSize());
            pstmt.setString(4, fileInfo.getFileType());
            pstmt.setBoolean(5, fileInfo.isExisted());
            pstmt.setBoolean(6, fileInfo.isSynced());

            pstmt.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    /**
     * 获取所有 is_existed 为 1 的文件名集合
     * @return 包含所有 is_existed=1 的文件名的 List<String>
     * @throws SQLException 如果数据库操作过程中发生错误
     */
    public List<String> getExistedFileNames() throws SQLException {
        List<String> fileNames = new ArrayList<>();
        String selectSql = "SELECT file_name FROM FileInfo WHERE is_existed = 1";
        try (PreparedStatement pstmt = conn.prepareStatement(selectSql)) {
            ResultSet rs = pstmt.executeQuery();
            while (rs.next()) {
                fileNames.add(rs.getString("file_name"));
            }
        }
        return fileNames;
    }

    /**
     * 获取所有 is_synced 为 1 的文件名集合
     * @return 包含所有 is_synced=1 的文件名的 List<String>，如果没有数据则返回 null
     * @throws SQLException 如果数据库操作过程中发生错误
     */
    public List<String> getSyncedFileNames() throws SQLException {
        List<String> fileNames = new ArrayList<>();
        String selectSql = "SELECT file_name FROM FileInfo WHERE is_synced = 1";
        try (PreparedStatement pstmt = conn.prepareStatement(selectSql)) {
            ResultSet rs = pstmt.executeQuery();
            while (rs.next()) {
                fileNames.add(rs.getString("file_name"));
            }
        }
        return fileNames.isEmpty() ? null : fileNames;
    }


    // 方法：关闭数据库连接
    public void closeConnection() throws SQLException {
        if (conn != null && !conn.isClosed()) {
            conn.close();
        }
    }

    // 主方法，用于测试

}